Для разработки программ на Java нам потребуется специальный комплект для разработки JDK (Java Development Kit). JDK включает ряд программ и утилит, которые позволяют компилировать, запускать программы на Java, а также выполнять ряд других функций.

JDK от Oracle для Windows (x64), Linux (x64, ARM64) и MacOS (x64, ARM64) доступны по адресу https://www.oracle.com/java/technologies/downloads/

OpenJDK для Windows (x64), Linux (x64, ARM64) и MacOS (x64, ARM64) доступны по адресу https://jdk.java.net/21/

OpenJDK предоставляет только архивы, Oracle также предоставляет установочные пакеты. Рассмотрим установку JDK для различных систем.

Установка на Windows

Установка с помощью установщика

Наиболее распространенный вариант установки JDK на Windows - это применение установщика с официального сайта Oracle. В частности, перейдем на страницу: https://www.oracle.com/java/technologies/downloads/#jdk22-windows

Нажмем на кнопку Next. На следующем экране необходимо указать, в какую папку будет производиться установка:

Оставим выбор папки по умолчанию и нажмем на Next для выполнения установки.

После завершения установки JDK мы увидим вот такое окно:

При установке JDK все файлы по умолчанию помещаются в каталог C:\Program Files\Java\jdk-[номер_версии] (если при установке не было изменено расположение). Так, если мы откроем в нем подкаталог bin, то мы сможем увидеть в нем ряд утилит. Нас прежде всего интересует утилита компилятора javac и утилита java.exe. javac компилирует код на языке Java в бинарный файл, а java.exe позволяет запускать скомпилированный файл:

Установка через пакетный менеджер

Через пакетный менеджер winget также можно установить OpenJDK от Microsoft. Для этого в командной строке/PowerShell надо выполнить команду:

winget install Microsoft.OpenJDK.21

В данном случае устанавливается 21-версия JDK.

Установка на Linux

Если мы используем JDK от Oracle, то в данном случае нам доступен ряд вариантов установки. В частности, перейдем на страницу: https://www.oracle.com/java/technologies/downloads/#jdk22-linux

• ARM64 Compressed Archive: архив для систем на архитектуре ARM64

• ARM64 RPM Package: RPM-пакет для систем на архитектуре ARM64, которые для управления пакетами применяют RPM (например, Fedora, Suse и т.д.)

• x64 Compressed Archive: архив для систем на архитектуре Intel x86-64

• x64 Debian Package: Debian-пакет для систем на архитектуре Intel x86-64 (например, Ubuntu, Debian и т.д.)

• x64 RPM Package: RPM-пакет для систем на архитектуре Intel x86-64, которые для управления пакетами применяют RPM (например, Fedora, Suse и т.д.)

Если наша операционная система Ubuntu (на платформе Intel x86-64), то выберем пункт x64 Debian Package, и нам загрузится debian-пакет (в моем случае файл "jdk-22_linux-x64_bin.deb"). Для его установки выполним команду

sudo dpkg -i jdk-22_linux-x64_bin.deb

Если у нас операционная система, которая для управления пакетами применяет RPM, например, Fedora, Suse и др, на платформе Intel x86-64, то необходимо выбрать пункт x64 RPM Package. И затем установить загруженный пакет командой

sudo rpm -ivh jdk-22_linux-x64_bin.rpm

Если у нас ОС Fedora, Suse и др, на платформе ARM64, то необходимо выбрать пункт ARM64 RPM Package. И затем установить загруженный пакет командой

sudo rpm -ivh jdk-22_linux-aarch64_bin.rpm

Также для различных операционных систем в репозиториях могут быть доступны пакеты JDK для установки. Например, установка с помощью пакетного менеджера snap:

sudo snap install openjdk

Установка с помощью пакетного менеджера apt:

sudo apt install default-jdk 

Установка определенной версии JDK с помощью пакетного менеджера apt:

sudo apt install openjdk-22-jdk-headless

В случае с установкой архивов все идентично для всех основных систем на базе Linux - загружается архив, распаковывается в определенное место. Затем в переменные среды добавляется путь к папке bin распакованного архива.

Установка Java на MacOS

Для установки Java на MacOS перейдем на страницу загрузок на сайте Oracle по адресу https://www.oracle.com/java/technologies/downloads/#jdk21-mac:

Здесь нам доступно 4 варианта пакетов:

• ARM64 Compressed Archive: архивный пакет для MacOS на ARM

• ARM64 DMG Installer: установщик для MacOS на архитектуре ARM

• x64 Compressed Archive: архивный пакет для MacOS на архитектуре Intel x86-64

• x64 DMG Installer: установщик для MacOS на архитектуре Intel x86-64

Загрузим и после загрузки запустим пакет установщика. Вначале нам отобразится приветственное окно.

Далее на всех последующих шагах оставим все опции по умолчанию. И после установки нам отобразится окно об ее успешном окончании:

Проверка установки

После установки Java перейдем к командной строке/терминалу и для проверки версии введем команду

java -version

Консоль нам должна в ответ ввести номер только что установленной версии JDK (в моем случае 22-й версии):

java 22 2024-03-19
Java(TM) SE Runtime Environment (build 22+36-2370)
Java HotSpot(TM) 64-Bit Server VM (build 22+36-2370, mixed mode, sharing)

Итак, после установки JDK создадим первую программу на Java.

Итак, после установки JDK создадим первое приложение на языке Java. Что необходимо для создания программы на Java? Прежде всего нам надо написать код программы, и для этого нужен текстовый редактор. Можно использовать любой текстовый редактор, например, Notepad++.

И чтобы превратить код программы в исполняемое приложение необходим компилятор. Компилятор устанавливается вместе с JDK.

Итак, создадим на жестком диске какой-нибудь каталог, в котором будут располагаться файлы с исходным кодом на языке Java. Допустим, это будет каталог C:/Java. Затем создадим в этом каталоге текстовый файл, который переименуем в Program.java. Откроем этот файл в любом текстовом редакторе и наберем в нем следующую программу:

Java является объектно-ориентированным языком, поэтому вся программа представляется в виде набора взаимодействующих классов. В данном случае определен один класс Program.

При определении класса вначале идет модификатор доступа public, который указывает, что данный класс будет доступен всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово class, а затем название класса. То есть класс называется Program. После названия в фигурных скобках расположено содержимое класса.

Класс может содержать различные переменные и методы. В данном случае у нас объявлен один метод main. Это главный метод в любой программе на Java, он является входной точкой программы и с него начинается все управление. Он обязательно должен присутствовать в программе.

Метод main также имеет модификатор public. Слово static указывает, что метод main - статический, а слово void - что он не возвращает никакого значения. Позже мы подробнее разберем, что все это значит.

Далее в скобках у нас идут параметры метода - String args[] - это массив args, который хранит значения типа String, то есть строки. В данном случае ни нам пока не нужны, но в реальной программе это те строковые параметры, которые передаются при запуске программы из командной строки.

После списка параметров в фигурных скобках идет тело метода - это собственно те инструкции, которые и будет выполнять метод. В данном случае фактически определени определена только одна инструкция - вывод на консоль некоторой строки. Для вывода на консоль используется встроенный метод System.out.println(). В этот метод передается выводимая строка. Каждая инструкция завершается точкой с запятой.

Теперь скомпилируем написанную программу. Откроем командную строку (в Windows) или терминал в Linux/MacOS и введем там соответствующие команды. Первым делом перейдем в каталог, где лежит наш файл с программой с помощью команды cd:

cd C:\Java

В данном случае файл находится в каталоге C:\Java.

Затем cкомпилируем программу с помощью команды

javac Program.java

Компилятор языка Java представляет утилиту javac. Через пробел название нашего файла, который содержит класс программы.

После этого программа компилируется в байт-код, и в каталоге C:\Java можно будет найти новый файл Program.class. Это и будет файл с байт-кодом программы. Теперь нам надо его запустить с помощью утилиты java:

java Program

Здесь уже расширение у файла не надо использовать.

Для ОС Windows весь процесс будет выглядеть следующим образом:

В примере выше весь процесс разбивался на два этапа:

1. Компилятор javac создает из программы на языке Java файл с расширением *.class, который содержит байт-код для виртуальной машины Java или JVM

2. Утилита java запускает скомпилированный байт-код из файла с расширением *.class. То есть происходит выполнение программы

Но в последних версиях Java также стало возможно сразу выполнить код программы на языке Java:

C:\Java>java Program.java
Hello METANIT.COM!

C:\Java>

В этом случае утилите java передается файл с исходным кодом. При этом файла с расширением *.class не создается.

В прошлой теме мы рассмотрели, как создавать первую программу с последующим ее запуском в командной строке. Для упрощения разработки мы также можем использовать такие инструменты как IDE или интегрированные среды разработки, которые упрощают и ускоряют написание кода и создание приложений. На данный момент наиболее популярной средой разработки для Java является IntelliJ IDEA от компании JetBrains. Рассмотрим, как использовать данную среду.

Прежде всего загрузим установочный дистрибутив с официального сайта https://www.jetbrains.com/idea/download. По этому адресу можно найти пакеты для Windows, MacOS, Linux. Кроме того, сама среда доступна в двух версиях - Ultimate (платная с триальным бесплатным периодом) и Community (бесплатная). В данном случае выберем бесплатную версию Community.

Обратите внимание, что на сайте сначала идет платная Ultimate-версия и только потом бесплатная Community-версия. Эта среда доступна как для платформы Intel x64, так и для платформы ARM64. Для Windows и MacOS доступны установочные пакеты, для Linux доступны только архивы. Однако ряде ОС на Linux, например, на Ubuntu, для установки можно использовать пакетный менеджер snap и установить среду с помощью команды:

sudo snap install intellij-idea-community --classic

Стоит отметить, Community-версия не имеет ряда многих возможностей, которые доступны в Ultimate-версии (в частности, в Community недоступны опции для веб-приложений на Java). Но Community-версия тоже довольно функциональна и тоже позволяет делать довольно много, в том числе приложения на JavaFX и Android.

После установки запустим IntelliJ IDEA и создадим первый проект. Для этого на стартовом экране выберем New Project:

Далее откроется окно создания проекта. В левой части в качестве типа проекта выберем New Project.

В поле Name укажем имя проекта. В моем случае проект будет называться HelloJava.

В поле Location можно указать путь к проекту, если не устраивает путь по умолчанию.

Поскольку мы будем работать с языком Java, в поле Language выберем пункт Java

Кроме того, в поле JDK можно указать путь к Java SDK, который будет использоваться в проекте. Как правило, это поле по умолчанию уже содержит путь к JDK, который установлен на локальном компьютере. Если это поле пусто, то его надо установить.

После этого нажмем на кнопку Create. После этого среда создаст и откроет проект.

В левой части мы можем увидеть структуру проекта. Все файлы с исходным кодом помещаются в папку src. По умолчанию эта папка пуста, никаких файлов кода у нас в проекте пока нет. Поэтому добавим файл с исходным кодом. Для этого нажмем на папку src правой кнопкой мыши и в контекстном меню выберем пункт New -> Java Class:

После этого нам откроется небольшое окошко, в которое надо ввести имя класса. Пусть класс будет называться Program:

После нажатия на клавишу Enter в папку src будет добавлен новый файл с классом java (в случае выше класс Program). А в центральной части откроется его содержимое - собственно исходный код:

Изменим код класса следующим образом:

С помощью зеленой стрелки на панели инструментов или через меню Run -> Run... запустим проект.

И внизу IntelliJ IDEA отобразится окно вывода, где мы можем увидеть результат работы нашей программы.

Еще одной популярной средой программирования под Java является Netbeans. Проект NetBeans во многом поддерживается и спонсируется компанией Oracle, при этом его разработка ведется независимым сообществом разработчиков (Apache NetBeans Community). NetBeans является кроссплатформенным программным обеспечением, поэтому есть версии среды для различных платформ и ОС. Более подробную информацию можно найти на официальном сайте даной среды https://netbeans.apache.org/.

На данный момент последней версией является 12-я версия. Итак, установим последнюю версию NetBeans, загрузив со страницы https://netbeans.apache.org/download/nb121/nb121.html.

На странице загрузки мы можем найти два варианта: скомпилированные бинарные файлы в виде архива (пункт Binaries) и установщики для каждой конкретной операционной системы (пункт Installers). Загрузим среду в скомпилированном, выбрав пункт Binaries.

После выбора этой опции нас переадресует на страницу с непосредственной ссылкой на зеркало для загрузки:

После загрузки распакуем архив в папку, где мы хотим разместить среду Netbeans. Стоит отметить, что после распаковки архива мы можем уже сразу запустить среду, не надо ничего устанавливать. В архиве уже готовые для использования файлы. Для запуска в распакованном архиве в папке bin мы можем найти собственно запускаемые файлы. В случае с ОС Windows это netbeans.exe и netbeans64.exe

Запустим netbeans.exe или netbeans64.exe:

NetBeans довольно интеллектуально понятна, и с ней очень легко работать. Создадим новый проект. Для этого выберем в меню пункт File->New Project.... После этого перед нами откроется окно создания нового проекта:

В окне создания нового проекта выберем в левой колонке первый пункт - Java with Ant, а в правой в качестве типа проекта - Java Application. И нажмем кнопку Next >

При первом создании проекта для Java нам будет предложено активировать соответствующую функцию:

И на данном этапе нажмем на кноку Activate.

Затем откроется окно настроек проекта:

В поле Project Name дадим проекту какое-нибудь название (в моем случае это HelloApp). Для всех остальных полей можно оставить значения по умолчанию. Последнее поле "Create Main Class" указывает, что автоматически в проекте будет создан класс программы HelloApp, который будет находиться в одноименном пакете helloapp. И в завершении создания проекта нажмем на кнопку "Finish". И перед нами откроется новый проект в Netbeans:

Узкое окно слева отображает все открытые проекты и их структуру. В данном случае у нас открыт пока только один проект. А большое окно справа представляет редактор кода с некоторыми дополнительными функциями, как подцветка кода, интеллектуальная подсказка и т.д. Редактор кода уже имеет некоторое содержание по умолчанию:

Здесь, во-первых, много комментариев, которые нам не нужны и которые мы можем удалить. Во-вторых, в начале файла указывается, что класс будет находиться в пакете helloapp с помощью директивы package: package helloapp;. Затем, как уже рассматривалось в прошлой теме, у нас есть класс программы - класс HelloApp, который имеет метод main.

Изменим код по умолчанию на следующий, чтобы программа выводила простейшую строку на консоль:

Теперь запустим проект на выполнение. Для этого на панели инструментов NetBeans нажмем на зеленую стрелочку (либо можно нажать на клавишу F6, либо выбрать в меню пункт Run -> Run Project). И внизу NetBeans откроется окно вывода, в котором мы сможем наблюдать результаты нашей программы:

Фактически это окно вывода эквивалентно консоли за некоторыми исключениями.

Еще одной очень популярной средой для разработки приложений под Java является Eclipse. IDE Eclipse первоначально была создана и развивалась компанией IBM, но впоследствии разработка была выделена в отдельный проект Eclipse Foundation. Eclipse является бесплатной средой, которая к тому же обладает большими возможностями, позволяя создавать на Java самые разные приложения.

Для начала установим последнюю версию Eclipse, которую можно найти по адресу https://www.eclipse.org/downloads/. На странице загрузок найдем рядом с названием текущей версии Eclipse (на момент написания статьи это версия Oxygen) кнопку "Download" и нажмем на нее.

После нажатия на кнопку нас перенаправит собственно на страницу загрузки, где необходимо будет нажать на кнопку "Download" для загруки установочного пакета:

После загрузки установочного пакета запустим его:

По факту Eclipse - это целый набор сред для разных ситуаций и языков программирования. И программа установки предлагает нам выбрать одну из опций для инсталляции. Поскольку мы собираемся работать с Java, то нас будут интересовать в данном случае прежде всего две опции:

• Eclipse IDE for Java Developers

• Eclipse IDE for Enterprise Java and Web Developers

Первая опция предоставляет базовые возможности для работы с Java, а вторая позволяет также создавать веб-приложения и сервисы. По сути вторая опция включает и первую опцию. Поэтому выберем Eclipse IDE for Enterprise Java and Web Developers.

Далее надо будет указать папку для установки (или оставить выбранную папку по умолчанию), а также указать путь к JDK и нажать на кнопку Install:

Далее надо будет принять лицензионное соглашение:

И затем собственно начнется установка. После установки запустим Eclipse. Вначале будет предложено установить каталог для проектов. Оставим значение по умолчанию и нажмем на кнорку Launch:

Далее перейдем к пункту меню File -> New -> Project:

Далее нам откроется окно выбора шаблона проекта. Выберем Java Project и нажмем на кнопку Next:

Затем будет предложено установить настройки проекта. В частности, в поле Project Name необходимо задать имя проекта. Допустим, оно будет helloapp:

Также обращаю внимание на поле JRE, которое задает используемую версию Java. Здесь можно использовать версию по умолчанию или изменить ее в зависимости от того, какую версию JDK/JRE мы хотим использовать.

Кроме того, в самом низу окна есть поле Create module-info.java file. Пока эта опция не принципиальна, поэтому чтобы не создавать лишние файлы в проекте, можно снять отметку с этого поля.

Все остальные настройки можно оставить по умолчанию, и в конце нажмем на кнопку Finish для создания проекта.

Следующее диалоговое окно спросит, надо ли открывать перспективу проекта:

В данном случае эта возможность не имеет значения, но нажмем на кнопку Open Perspective.

После создания проект будет открыт в Eclipse. Если среда не открывает по умолчанию проект, то необходимо нажать на кнопку Restore:

По умолчанию проект будет пуст.

Все файлы с исходным кодом на Java в проекте помещаются в папку src. Нажмем на нее правой кнопкой мыши и в контекстном меню выберем New -> Class:

Затем откроется окно настройки класса. Здесь в поле Name необходимо задать название класса. Допустим, он будет называться Program. Все остальные настройки можно оставить по умолчанию:

После этого в проект будет добавлен файл Program.java, а в центральной части Eclipse мы сможем увидеть его код. Изменим этот код на следующий:

Для запуска проекта нажмем на панели инструментов на зеленую стрелочку, либо на пункт меню Run -> Run. И внизу среды в поле Console мы увидим результат работы программы (то есть фактически консольный вывод).

Основным строительным блоком программы на языке Java являются инструкции (statement). Каждая инструкция выполняет некоторое действие, например, вызовы методов, объявление переменных и присвоение им значений. После завершения инструкции в Java ставится точка с запятой (;). Данный знак указывает компилятору на конец инструкции. Например:

Данная строка представляет вызов метода System.out.println, который выводит на консоль строку "Hello Java!". В данном случае вызов метода является инструкцией и поэтому завершается точкой с запятой.

Кроме отдельных инструкций распространенной конструкцией является блок кода. Блок кода содержит набор инструкций, он заключается в фигурные скобки, а инструкции помещаются между открывающей и закрывающей фигурными скобками:

В этом блоке кода две инструкции, которые выводят на консоль определенную строку.

Выполнение программы. Метод main

Java является объектно-ориентированным языком, поэтому всю программу можно представить как набор взаимодействующих между собой классов и объектов. В первой главе при создании первого приложения программа была определена следующим образом:

То есть основу нашей программы составляет класс Program. При определении класса вначале идет модификатор доступа public, который указывает, что данный класс будет доступен всем, то есть мы сможем его запустить из командной строки. Далее идет ключевое слово class, а затем название класса. После названия класса идет блок кода, в котором расположено содержимое класса.

Входной точкой в программу на языке Java является метод main, который определен в классе Program. Именно с него начинается выполнение программы. Он обязательно должен присутствовать в программе. При этом его заголовок может быть только таким:

При запуске приложения виртуальная машина Java ищет в главном классе программы метод main с подобным заголовком, и после его обнаружения запускает его.

Вначале заголовка метода идет модификатор public, который указывает, что метод будет доступен извне. Слово static указывает, что метод main - статический, а слово void - что он не возвращает никакого значения. Далее в скобках у нас идут параметры метода - String args[] - это массив args, который хранит значения типа String, то есть строки. При запуске программы через этот массив мы можем передать в программу различные данные.

После заголовка метода идет его блок, который содержит набор выполняемых инструкций.

Комментарии

Код программы может содержать комментарии. Комментарии позволяют понять смысл программы, что делают те или иные ее части. При компиляции комментарии игнорируются и не оказывают никакого влияния на работу приложения и на его размер.

В Java есть два типа комментариев: однострочный и многострочный. Однострочный комментарий размещается на одной строке после двойного слеша //. А многострочный комментарий заключается между символами /* текст комментария */. Он может размещаться на нескольких строках. Например:

Для хранения данных в программе предназначены переменные. Переменная представляет именованную область памяти, которая хранит значение определенного типа. Каждая переменная имеет тип, имя и значение. Тип определяет, какую информацию может хранить переменная или диапазон допустимых значений.

Переменные объявляются следующим образом:

Например, определим переменную, которая будет называться x и будет иметь тип int:

В этом выражении мы объявляем переменную x типа int. То есть x будет хранить некоторое число не больше 4 байт.

В качестве имени переменной может выступать любое произвольное название, которое удовлетворяет следующим требованиям:

• имя может содержать любые алфавитно-цифровые символы, а также знак подчеркивания, при этом первый символ в имени не должен быть цифрой

• в имени не должно быть знаков пунктуации и пробелов

• имя не может быть ключевым словом языка Java

Кроме того, при объявлении и последующем использовании надо учитывать, что Java - регистрозависимый язык, поэтому следующие объявления int num; и int NUM; будут представлять две разных переменных.

Объявив переменную, мы можем присвоить ей значение:

Также можно присвоить значение переменной при ее объявлении. Этот процесс называется инициализацией:

Если мы не присвоим переменной значение до ее использования, то мы можем получить ошибку, например, в следующем случае:

Через запятую можно объявить сразу несколько переменных одного типа:

Также можно их сразу инициализировать:

Отличительной особенностью переменных является то, что мы можем в процессе работы программы изменять их значение:

Ключевое слово var

Начиная с Java 10 в язык было добавлено ключевое слово var, которое также позволяет определять переменную:

Слово var ставится вместо типа данных, а сам тип переменной выводится из того значения, которое ей присваивается. Например, переменной x присваивается число 10, значит, переменная будет представлять тип int.

Но если переменная объявляется с помощью var, то мы обязательно должны инициализировать ее, то есть предоставить ей начальное значение, иначе мы получим ошибку, как, например, в следующем случае:

Константы

Кроме переменных, в Java для хранения данных можно использовать константы. В отличие от переменных константам можно присвоить значение только один раз. Константа объявляется также, как и переменная, только вначале идет ключевое слово final:

Как правило, константы имеют имена в верхнем регистре.

Константы позволяют задать такие переменные, которые не должны больше изменяться. Например, если у нас есть переменная для хранения числа pi, то мы можем объявить ее константой, так как ее значение постоянно.

Одной из основных особенностей Java является то, что данный язык является строго типизированным. А это значит, что каждая переменная и константа представляет определенный тип и данный тип строго определен. Тип данных определяет диапазон значений, которые может хранить переменная или константа.

Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.

• boolean: хранит значение true или false

  ?

  1 2	boolean isActive = false; boolean isAlive = true;

• byte: хранит целое число от -128 до 127 и занимает 1 байт

  ?

  1 2	byte a = 3; byte b = 8;

• short: хранит целое число от -32768 до 32767 и занимает 2 байта

  ?

  1 2	short a = 3; short b = 8;

• int: хранит целое число от -2147483648 до 2147483647 и занимает 4 байта

  ?

  1 2	int a = 4; int b = 9;

• long: хранит целое число от –9 223 372 036 854 775 808 до 9 223 372 036 854 775 807 и занимает 8 байт

  ?

  1 2	long a = 5; long b = 10;

• double: хранит число с плавающей точкой от ±4.9*10-324 до ±1.7976931348623157*10308 и занимает 8 байт

  ?

  1 2	double x = 8.5; double y = 2.7;

  В качестве разделителя целой и дробной части в дробных литералах используется точка.

• float: хранит число с плавающей точкой от -3.4*1038 до 3.4*1038 и занимает 4 байта

  ?

  1 2	float x = 8.5F; float y = 2.7F;

• char: хранит одиночный символ в кодировке UTF-16 и занимает 2 байта, поэтому диапазон хранимых значений от 0 до 65535

При этом переменная может принимать только те значения, которые соответствуют ее типу. Если переменная представляет целочисленный тип, то она не может хранить дробные числа.

Целые числа

Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int, однако мы можем присваивать целочисленные литералы другим целочисленным типам: byte, long, short. В этом случае Java автоматически осуществляет соответствующие преобразования:

Однако если мы захотим присвоить переменной типа long очень большое число, которое выходит за пределы допустимых значений для типа int, то мы столкнемся с ошибкой во время компиляции:

Здесь число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int. И так как все целочисленные значения по умолчанию расцениваются как значения типа int, то компилятор укажет нам на ошибку. Чтобы решить проблему, надо добавить к числу суффикс l или L, который указывает, что число представляет тип long:

Как правило, значения для целочисленных переменных задаются в десятичной системе счисления, однако мы можем применять и другие системы счисления. Например:

Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате. Таким же образом восьмеричное значение указывается после символа 0, а двоичное значение - после символов 0b.

Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:

Числа с плавающей точкой

При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа double. И чтобы указать, что данное значение должно рассматриваться как float, нам надо использовать суффикс f:

И хотя в данном случае обе переменных имеют практически одно значения, но эти значения будут по-разному рассматриваться и будут занимать разное место в памяти.

Символы и строки

В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: char ch='e';. Кроме того, переменной символьного типа также можно присвоить целочисленное значение от 0 до 65535. В этом случае переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:

Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме, которое следует после символов "\u". Например, char ch='\u0066'; опять же будет хранить символ 'f'.

Символьные переменные не стоит путать со строковыми, 'a' не идентично "a". Строковые переменные представляют объект String, который в отличие от char или int не является примитивным типом в Java:

Кроме собственно символов, которые представляют буквы, цифры, знаки препинания, прочие символы, есть специальные наборы символов, которые называют управляющими последовательностями. Например, самая популярная последовательность - "\n". Она выполняет перенос на следующую строку. Например:

Результат выполнения данного кода:

Hello 
world

В данном случае последовательность \n будет сигналом, что необходимо сделать перевод на следующую строку.

Начиная с версии 15 Java поддерживает тестовые блоки (text blocks) - многострочный текст, облеченный в тройные кавычки. Рассмотрим, в чем их практическая польза. Например, выведем большой многострочный текст:

С помощью операции + мы можем присоединить к одному тексту другой, причем продолжение текста может располагаться на следующей строке. Чтобы при выводе текста происходил перенос на следующую строку, применяется последовательность \n.

Результат выполнения данного кода:

Вот мысль, которой весь я предан,
Итог всего, что ум скопил.
Лишь тот, кем бой за жизнь изведан,
Жизнь и свободу заслужил.

Текстовые блоки, которые появились в JDK15, позволяют упростить написание многострочного текста:

Весь текстовый блок оборачивается в тройные кавычки, при этом не надо использовать соединение строк или последовательность \n для их переноса. Результат выполнения программы будет тем же, что и в примере выше.

Наиболее простой способ взаимодействия с пользователем представляет консоль: мы можем выводить на консоль некоторую информацию или, наоборот, считывать с консоли некоторые данные. Для взаимодействия с консолью в Java применяется класс System, а его функциональность собственно обеспечивает консольный ввод и вывод.

Вывод на консоль

Для создания потока вывода в класс System определен объект out. В этом объекте определен метод println, который позволяет вывести на консоль некоторое значение с последующим переводом курсора консоли на следующую строку. Например:

В метод println передается любое значение, как правило, строка, которое надо вывести на консоль. И в данном случае мы получим следующий вывод:

Hello world!
Bye world...

При необходимости можно и не переводить курсор на следующую строку. В этом случае можно использовать метод System.out.print(), который аналогичен println за тем исключением, что не осуществляет перевода на следующую строку.

Консольный вывод данной программы:

Hello world!Bye world...

Но с помощью метода System.out.print также можно осуществить перевод каретки на следующую строку. Для этого надо использовать escape-последовательность \n:

Нередко необходимо подставлять в строку какие-нибудь данные. Например, у нас есть два числа, и мы хотим вывести их значения на экран. В этом случае мы можем, например, написать так:

Консольный вывод программы:

x=5; y=6

Но в Java есть также функция для форматированного вывода, унаследованная от языка С: System.out.printf(). С ее помощью мы можем переписать предыдущий пример следующим образом:

В данном случае символы %d обозначают спецификатор, вместо которого подставляет один из аргументов. Спецификаторов и соответствующих им аргументов может быть множество. В данном случае у нас только два аргумента, поэтому вместо первого %d подставляет значение переменной x, а вместо второго - значение переменной y. Сама буква d означает, что данный спецификатор будет использоваться для вывода целочисленных значений.

Кроме спецификатора %d мы можем использовать еще ряд спецификаторов для других типов данных:

• %x: для вывода шестнадцатеричных чисел

• %f: для вывода чисел с плавающей точкой

• %e: для вывода чисел в экспоненциальной форме, например, 1.3e+01

• %c: для вывода одиночного символа

• %s: для вывода строковых значений

Например:

При выводе чисел с плавающей точкой мы можем указать количество знаков после запятой, для этого используем спецификатор на %.2f, где .2 указывает, что после запятой будет два знака. В итоге мы получим следующий вывод:

Name: Tom  Age: 30  Height: 1,70

Ввод с консоли

Для получения ввода с консоли в классе System определен объект in. Однако непосредственно через объект System.in не очень удобно работать, поэтому, как правило, используют класс Scanner, который, в свою очередь использует System.in. Например, напишем маленькую программу, которая осуществляет ввод чисел:

Так как класс Scanner находится в пакете java.util, то мы вначале его импортируем с помощью инструкции import java.util.Scanner.

Для создания самого объекта Scanner в его конструктор передается объект System.in. После этого мы можем получать вводимые значения. Например, в данном случае вначале выводим приглашение к вводу и затем получаем вводимое число в переменную num.

Чтобы получить введенное число, используется метод in.nextInt();, который возвращает введенное с клавиатуры целочисленное значение.

Пример работы программы:

Input a number: 5
Your number: 5

Класс Scanner имеет еще ряд методов, которые позволяют получить введенные пользователем значения:

• next(): считывает введенную строку до первого пробела

• nextLine(): считывает всю введенную строку

• nextInt(): считывает введенное число int

• nextDouble(): считывает введенное число double

• nextBoolean(): считывает значение boolean

• nextByte(): считывает введенное число byte

• nextFloat(): считывает введенное число float

• nextShort(): считывает введенное число short

То есть для ввода значений каждого примитивного типа в классе Scanner определен свой метод.

Например, создадим программу для ввода информации о человеке:

Здесь последовательно вводятся данные типов String, int, float и потом все введенные данные вместе выводятся на консоль. Пример работы программы:

Input name: Tom
Input age: 34
Input height: 1,7
Name: Tom  Age: 34  Height: 1,70

Обратите внимание, что для ввода значения типа float (то же самое относится к типу double) применяется число "1,7", где разделителем является запятая, а не "1.7", где разделителем является точка. В данном случае все зависит от текущей языковой локализации системы. В моем случае русскоязычная локализация, соответственно вводить необходимо числа, где разделителем является запятая. То же самое касается многих других локализаций, например, немецкой, французской и т.д., где применяется запятая.

Большинство операций в Java аналогичны тем, которые применяются в других си-подобных языках. Есть унарные операции (выполняются над одним операндом), бинарные - над двумя операндами, а также тернарные - выполняются над тремя операндами. Операндом является переменная или значение (например, число), участвующее в операции. Рассмотрим все виды операций.

В арифметических операциях участвуют числа. В Java есть бинарные арифметические операции (производятся над двумя операндами) и унарные (выполняются над одним операндом). К бинарным операциям относят следующие:

• +

  операция сложения двух чисел:

  ?

  1 2 3 4

  int a = 10; int b = 7; int c = a + b;  // 17 int d = 4 + b;  // 11

• -

  операция вычитания двух чисел:

  ?

  1 2 3 4

  int a = 10; int b = 7; int c = a - b;  // 3 int d = 4 - a;  // -6

• *

  операция умножения двух чисел

  ?

  1 2 3 4

  int a = 10; int b = 7; int c = a * b;  // 70 int d = b * 5;  // 35

• /

  операция деления двух чисел:

  ?

  1 2 3 4

  int a = 20; int b = 5; int c = a / b;  // 4 double d = 22.5 / 4.5;  // 5.0

  При делении стоит учитывать, что если в операции участвуют два целых числа, то результат деления будет округляться до целого числа, даже если результат присваивается переменной float или double:

  ?

  1 2	double k = 10 / 4;     // 2 System.out.println(k);

  Чтобы результат представлял число с плавающей точкой, один из операндов также должен представлять число с плавающей точкой:

  ?

  1 2	double k = 10.0 / 4;     // 2.5 System.out.println(k);

• %

  получение остатка от деления двух чисел:

  ?

  1 2 3 4

  int a = 33; int b = 5; int c = a % b;  // 3 int d = 22 % 4; // 2 (22 - 4*5 = 2)

Также есть две унарные арифметические операции, которые производятся над одним числом: ++ (инкремент) и -- (декремент). Каждая из операций имеет две разновидности: префиксная и постфиксная:

• ++ (префиксный инкремент)

  Предполагает увеличение переменной на единицу, например, z=++y (вначале значение переменной y увеличивается на 1, а затем ее значение присваивается переменной z)

  ?

  1 2 3 4

  int a = 8; int b = ++a; System.out.println(a);  // 9 System.out.println(b);  // 9

• ++ (постфиксный инкремент)

  Также представляет увеличение переменной на единицу, например, z=y++ (вначале значение переменной y присваивается переменной z, а потом значение переменной y увеличивается на 1)

  ?

  1 2 3 4

  int a = 8; int b = a++; System.out.println(a);  // 9 System.out.println(b);  // 8

• -- (префиксный декремент)

  уменьшение переменной на единицу, например, z=--y (вначале значение переменной y уменьшается на 1, а потом ее значение присваивается переменной z)

  ?

  1 2 3 4

  int a = 8; int b = --a; System.out.println(a);  // 7 System.out.println(b);  // 7

• -- (постфиксный декремент)

  z=y-- (сначала значение переменной y присваивается переменной z, а затем значение переменной y уменьшается на 1)

  ?

  1 2 3 4

  int a = 8; int b = a--; System.out.println(a);  // 7 System.out.println(b);  // 8

Приоритет арифметических операций

Одни операции имеют больший приоритет, чем другие, и поэтому выполняются вначале. Операции в порядке уменьшения приоритета:

++ (постфиксный инкремент), -- (постфиксный декремент)

++ (префиксный инкремент), -- (префиксный декремент)

* (умножение), / (деление), % (остаток от деления)

+ (сложение), - (вычитание)

Приоритет операций следует учитывать при выполнении набора арифметических выражений:

Вначале будет выполняться операция инкремента ++b, которая имеет больший приоритет - она увеличит значение переменной b и возвратит его в качестве результата. Затем выполняется умножение 5 * ++b, и только в последнюю очередь выполняется сложение a + 5 * ++b

Скобки позволяют переопределить порядок вычислений:

Несмотря на то, что операция сложения имеет меньший приоритет, но вначале будет выполняться именно сложение, а не умножение, так как операция сложения заключена в скобки.

Ассоциативность операций

Кроме приоритета операции отличаются таким понятием как ассоциативность. Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:

• Левоассоциативные операторы, которые выполняются слева направо

• Правоассоциативные операторы, которые выполняются справа налево

Так, некоторые операции, например, операции умножения и деления, имеют один и тот же приоритет. Какой же тогда будет результат в выражении:

Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2)? Ведь в зависимости от трактовки мы получим разные результаты.

Все арифметические операторы (кроме префиксного инкремента и декремента) являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2, то есть результатом будет 4.

Операции с числами с плавающей точкой

Следует отметить, что числа с плавающей точкой не подходят для финансовых и других вычислений, где ошибки при округлении могут быть критичными. Например:

В данном случае переменная d будет равна не 0.9, как можно было бы изначально предположить, а 0.8999999999999999. Подобные ошибки точности возникают из-за того, что на низком уровне для представления чисел с плавающей точкой применяется двоичная система, однако для числа 0.1 не существует двоичного представления, также как и для других дробных значений. Поэтому в таких случаях обычно применяется класс BigDecimal, который позволяет обойти подобные ситуации.

Поразрядные операции выполняются над отдельными разрядами или битами чисел. В данных операциях в качестве операндов могут выступать только целые числа.

Каждое число имеет определенное двоичное представление. Например, число 4 в двоичной системе 100, а число 5 - 101 и так далее.

К примеру, возьмем следующие переменные:

Тип byte занимает 1 байт или 8 бит, соответственно представлен 8 разрядами. Поэтому значение переменной b в двоичном коде будет равно 00000111. Тип short занимает в памяти 2 байта или 16 бит, поэтому число данного типа будет представлено 16 разрядами. И в данном случае переменная s в двоичной системе будет иметь значение 0000 0000 0000 0111.

Для записи чисел со знаком в Java применяется дополнительный код (two's complement), при котором старший разряд является знаковым. Если его значение равно 0, то число положительное, и его двоичное представление не отличается от представления беззнакового числа. Например, 0000 0001 в десятичной системе 1.

Если старший разряд равен 1, то мы имеем дело с отрицательным числом. Например, 1111 1111 в десятичной системе представляет -1. Соответственно, 1111 0011 представляет -13.

Логические операции

Логические операции над числами представляют поразрядные операции. В данном случае числа рассматриваются в двоичном представлении, например, 2 в двоичной системе равно 10 и имеет два разряда, число 7 - 111 и имеет три разряда.

• & (логическое умножение)

  Умножение производится поразрядно, и если у обоих операндов значения разрядов равно 1, то операция возвращает 1, иначе возвращается число 0. Например:

  ?

  1 2 3 4 5 6 7

  int a1 = 2; //010  int b1 = 5;//101  System.out.println(a1&b1); // результат 0               int a2 = 4; //100 int b2 = 5; //101 System.out.println(a2 & b2); // результат 4

  В первом случае у нас два числа 2 и 5. 2 в двоичном виде представляет число 010, а 5 - 101. Поразрядное умножение чисел (0*1, 1*0, 0*1) дает результат 000.

  Во втором случае у нас вместо двойки число 4, у которого в первом разряде 1, так же как и у числа 5, поэтому здесь результатом операции (1*1, 0*0, 0 *1) = 100 будет число 4 в десятичном формате.

• | (логическое сложение)

  Данная операция также производится по двоичным разрядам, но теперь возвращается единица, если хотя бы у одного числа в данном разряде имеется единица (операция "логическое ИЛИ"). Например:

  ?

  1 2 3 4 5 6

  int a1 = 2; //010 int b1 = 5;//101 System.out.println(a1|b1); // результат 7 - 111 int a2 = 4; //100 int b2 = 5;//101 System.out.println(a2 | b2); // результат 5 - 101

• ^ (логическое исключающее ИЛИ)

  Также эту операцию называют XOR, нередко ее применяют для простого шифрования:

  ?

  1 2 3 4 5 6 7

  int number = 45; // 1001 Значение, которое надо зашифровать - в двоичной форме 101101 int key = 102; //Ключ шифрования - в двоичной системе 1100110 int encrypt = number ^ key; //Результатом будет число 1001011 или 75 System.out.println("Зашифрованное число: " +encrypt);   int decrypt = encrypt ^ key; // Результатом будет исходное число 45 System.out.println("Расшифрованное число: " + decrypt);

  Здесь также производятся поразрядные операции. Если у нас значения текущего разряда у обоих чисел разные, то возвращается 1, иначе возвращается 0. Например, результатом выражения 9^5 будет число 12. А чтобы расшифровать число, мы применяем обратную операцию к результату.

• ~ (логическое отрицание)

  Поразрядная операция, которая инвертирует все разряды числа: если значение разряда равно 1, то оно становится равным нулю, и наоборот.

  ?

  1 2	byte a = 12;                 // 0000 1100     System.out.println(~a);     //  1111 0011   или -13

Операции сдвига

Операции сдвига также производятся над разрядами чисел. Сдвиг может происходить вправо и влево.

• a<<b - сдвигает число a влево на b разрядов. Например, выражение 4<<1 сдвигает число 4 (которое в двоичном представлении 100) на один разряд влево, в результате получается число 1000 или число 8 в десятичном представлении.

• a>>b - смещает число a вправо на b разрядов. Например, 16>>1 сдвигает число 16 (которое в двоичной системе 10000) на один разряд вправо, то есть в итоге получается 1000 или число 8 в десятичном представлении.

• a>>>b - в отличие от предыдущих типов сдвигов данная операция представляет беззнаковый сдвиг - сдвигает число a вправо на b разрядов. Например, выражение -8>>>2 будет равно 1073741822.

Таким образом, если исходное число, которое надо сдвинуть в ту или другую сторону, делится на два, то фактически получается умножение или деление на два. Поэтому подобную операцию можно использовать вместо непосредственного умножения или деления на два, так как операция сдвига на аппаратном уровне менее дорогостоящая операция в отличие от операции деления или умножения.

Условные выражения представляют собой некоторое условие и возвращают значение типа boolean, то есть значение true (если условие истинно), или значение false (если условие ложно). К условным выражениям относятся операции сравнения и логические операции.

Операции сравнения

В операциях сравнения сравниваются два операнда, и возвращается значение типа boolean - true, если выражение верно, и false, если выражение неверно.

• ==

  сравнивает два операнда на равенство и возвращает true (если операнды равны) и false (если операнды не равны)

  ?

  1 2 3 4

  int a = 10; int b = 4; boolean c = a == b;         // false boolean d = a == 10;       // true

• !=

  сравнивает два операнда и возвращает true, если операнды НЕ равны, и false, если операнды равны

  ?

  1 2 3 4

  int a = 10; int b = 4; boolean c = a != b;         // true boolean d = a != 10;       // false

• < (меньше чем)

  Возвращает true, если первый операнд меньше второго, иначе возвращает false

  ?

  1 2 3

  int a = 10; int b = 4; boolean c = a < b;   // false

• > (больше чем)

  Возвращает true, если первый операнд больше второго, иначе возвращает false

  ?

  1 2 3

  int a = 10; int b = 4; boolean c = a > b;   // true

• >= (больше или равно)

  Возвращает true, если первый операнд больше второго или равен второму, иначе возвращает false

  ?

  1 2 3

  boolean c = 10 >= 10;    // true boolean b = 10 >= 4;     // true boolean d = 10 >= 20;    // false

• <= (меньше или равно)

  Возвращает true, если первый операнд меньше второго или равен второму, иначе возвращает false

  ?

  1 2 3

  boolean c = 10 <= 10;    // true boolean b = 10 <= 4;     // false boolean d = 10 <= 20;    // true

Логические операции

Также в Java есть логические операции, которые также представляют условие и возвращают true или false и обычно объединяют несколько операций сравнения. К логическим операциям относят следующие:

• |

  c=a|b; (c равно true, если либо a, либо b (либо и a, и b) равны true, иначе c будет равно false)

• &

  c=a&b; (c равно true, если и a, и b равны true, иначе c будет равно false)

• !

  c=!b; (c равно true, если b равно false, иначе c будет равно false)

• ^

  c=a^b; (c равно true, если либо a, либо b (но не одновременно) равны true, иначе c будет равно false)

• ||

  c=a||b; (c равно true, если либо a, либо b (либо и a, и b) равны true, иначе c будет равно false)

• &&

  c=a&&b; (c равно true, если и a, и b равны true, иначе c будет равно false)

Здесь у нас две пары операций | и || (а также & и &&) выполняют похожие действия, однако же они не равнозначны.

Выражение c=a|b; будет вычислять сначала оба значения - a и b и на их основе выводить результат.

В выражении же c=a||b; вначале будет вычисляться значение a, и если оно равно true, то вычисление значения b уже смысла не имеет, так как у нас в любом случае уже c будет равно true. Значение b будет вычисляться только в том случае, если a равно false

То же самое касается пары операций &/&&. В выражении c=a&b; будут вычисляться оба значения - a и b.

В выражении же c=a&&b; сначала будет вычисляться значение a, и если оно равно false, то вычисление значения b уже не имеет смысла, так как значение c в любом случае равно false. Значение b будет вычисляться только в том случае, если a равно true

Таким образом, операции || и && более удобны в вычислениях, позволяя сократить время на вычисление значения выражения и тем самым повышая производительность. А операции | и & больше подходят для выполнения поразрядных операций над числами.

Примеры:

В завершении рассмотрим операции присваивания, которые в основном представляют комбинацию простого присваивания с другими операциями:

• =

  просто приравнивает одно значение другому: c=b;

• +=

  c+=b; (переменной c присваивается результат сложения c и b)

• -=

  c-=b; (переменной c присваивается результат вычитания b из c)

• *=

  c*=b; (переменной c присваивается результат произведения c и b)

• /=

  c/=b; (переменной c присваивается результат деления c на b)

• %=

  c%=b; (переменной c присваивается остаток от деления c на b)

• &=

  c&=b; (переменной c присваивается значение c&b)

• |=

  c|=b; (переменной c присваивается значение c|b)

• ^=

  c^=b; (переменной c присваивается значение c^b)

• <<=

  c<<=b; (переменной c присваивается значение c<<b)

• >>=

  c>>=b; (переменной c присваивается значение c>>b)

• >>>=

  c>>>=b; (переменной c присваивается значение c>>>b)

Примеры операций:

Приоритет операций

При работе с операциями важно понимать их приоритет, который можно описать следующей таблицей:

Чем выше оператор в этой таблице, тем больше его приоритет. При этом скобки повышают приоритет операции, используемой в выражении.

Каждый базовый тип данных занимает определенное количество байт памяти. Это накладывает ограничение на операции, в которые вовлечены различные типы данных. Рассмотрим следующий пример:

В данном коде мы столкнемся с ошибкой. Хотя и тип byte, и тип int представляют целые числа. Более того, значение переменной a, которое присваивается переменной типа byte, вполне укладывается в диапазон значений для типа byte (от -128 до 127). Тем не менее мы сталкиваемся с ошибкой на этапе компиляции. Поскольку в данном случае мы пытаемся присвоить некоторые данные, которые занимают 4 байта, переменной, которая занимает всего один байт.

Тем не менее в программе может потребоваться, чтобы подобное преобразование было выполнено. В этом случае необходимо использовать операцию преобразования типов (операция ()):

Операция преобразования типов предполагает указание в скобках того типа, к которому надо преобразовать значение. Например, в случае операции (byte)a, идет преобразование данных типа int в тип byte. В итоге мы получим значение типа byte.

Явные и неявные преобразования

Когда в одной операции вовлечены данные разных типов, не всегда необходимо использовать операцию преобразования типов. Некоторые виды преобразований выполняются неявно, автоматически.

Автоматические преобразования

Стрелками на рисунке показано, какие преобразования типов могут выполняться автоматически. Пунктирными стрелками показаны автоматические преобразования с потерей точности.

Автоматически без каких-либо проблем производятся расширяющие преобразования (widening) - они расширяют представление объекта в памяти. Например:

В данном случае значение типа byte, которое занимает в памяти 1 байт, расширяется до типа int, которое занимает 4 байта.

Расширяющие автоматические преобразования представлены следующими цепочками:

byte -> short -> int -> long

int -> double

short -> float -> double

char -> int

Автоматические преобразования с потерей точности

Некоторые преобразования могут производиться автоматически между типами данных одинаковой разрядности или даже от типа данных с большей разрядностью к типа с меньшей разрядностью. Это следующие цепочки преобразований: int -> float, long -> float и long -> double. Они производятся без ошибок, но при преобразовании мы можем столкнуться с потерей информации.

Например:

Явные преобразования

Во всех остальных преобразованиях примитивных типов явным образом применяется операция преобразования типов. Обычно это сужающие преобразования (narrowing) от типа с большей разрядностью к типу с меньшей разрядностью:

Потеря данных при преобразовании

При применении явных преобразований мы можем столкнуться с потерей данных. Например, в следующем коде у нас не возникнет никаких проблем:

Число 5 вполне укладывается в диапазон значений типа byte, поэтому после преобразования переменная b будет равна 5. Но что будет в следующем случае:

Результатом будет число 2. В данном случае число 258 вне диапазона для типа byte (от -128 до 127), поэтому произойдет усечение значения. Почему результатом будет именно число 2?

Число a, которое равно 258, в двоичном системе будет равно 00000000 00000000 00000001 00000010. Значения типа byte занимают в памяти только 8 бит. Поэтому двоичное представление числа int усекается до 8 правых разрядов, то есть 00000010, что в десятичной системе дает число 2.

Усечение рациональных чисел до целых

При преобразовании значений с плавающей точкой к целочисленным значениям, происходит усечение дробной части:

Здесь значение числа b будет равно 56, несмотря на то, что число 57 было бы ближе к 56.9898. Чтобы избежать подобных казусов, надо применять функцию округления, которая есть в математической библиотеке Java:

Преобразования при операциях

Нередки ситуации, когда приходится применять различные операции, например, сложение и произведение, над значениями разных типов. Здесь также действуют некоторые правила:

• если один из операндов операции относится к типу double, то и второй операнд преобразуется к типу double

• если предыдущее условие не соблюдено, а один из операндов операции относится к типу float, то и второй операнд преобразуется к типу float

• если предыдущие условия не соблюдены, один из операндов операции относится к типу long, то и второй операнд преобразуется к типу long

• иначе все операнды операции преобразуются к типу int

Примеры преобразований:

Так как в операции участвует значение типа double, то и другое значение приводится к типу double и сумма двух значений a+b будет представлять тип double.

Другой пример:

Две переменных типа byte и short (не double, float или long), поэтому при сложении они преобразуются к типу int, и их сумма a+b представляет значение типа int. Поэтому если затем мы присваиваем эту сумму переменной типа byte, то нам опять надо сделать преобразование типов к byte.

Если в операциях участвуют данные типа char, то они преобразуются в int:

Одним из фундаментальных элементов многих языков программирования являются условные конструкции. Данные конструкции позволяют направить работу программы по одному из путей в зависимости от определенных условий.

В языке Java используются следующие условные конструкции: if..else и switch..case

Конструкция if/else

Выражение if/else проверяет истинность некоторого условия и в зависимости от результатов проверки выполняет определенный код:

После ключевого слова if ставится условие. И если это условие выполняется, то срабатывает код, который помещен в далее в блоке if после фигурных скобок. В качестве условий выступает операция сравнения двух чисел.

Так как, в данном случае первое число больше второго, то выражение num1 > num2 истинно и возвращает значение true. Следовательно, управление переходит в блок кода после фигурных скобок и начинает выполнять содержащиеся там инструкции, а конкретно метод System.out.println("Первое число больше второго");. Если бы первое число оказалось бы меньше второго или равно ему, то инструкции в блоке if не выполнялись бы.

Но что, если мы захотим, чтобы при несоблюдении условия также выполнялись какие-либо действия? В этом случае мы можем добавить блок else:

Но при сравнении чисел мы можем насчитать три состояния: первое число больше второго, первое число меньше второго и числа равны. С помощью выражения else if, мы можем обрабатывать дополнительные условия:

Также мы можем соединить сразу несколько условий, используя логические операторы:

Здесь блок if будет выполняться, если num1 > num2 равно true и одновременно num1>7 равно true.

Конструкция switch

Конструкция switch/case аналогична конструкции if/else, так как позволяет обработать сразу несколько условий:

После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после операторов сase. И если совпадение найдено, то будет выполняет соответствующий блок сase.

В конце блока сase ставится оператор break, чтобы избежать выполнения других блоков. Например, если бы убрали оператор break в следующем случае:

то выполнился бы блок case 8, (поскольку переменная num равна 8). Но так как в этом блоке оператор break отсутствует, то начал бы выполняться блок case 9.

Если мы хотим также обработать ситуацию, когда совпадения не будет найдено, то можно добавить блок default, как в примере выше. Хотя блок default необязателен.

Также мы можем определить одно действие сразу для нескольких блоков case подряд:

Тернарная операция

Тернарную операция имеет следующий синтаксис: [первый операнд - условие] ? [второй операнд] : [третий операнд]. Таким образом, в этой операции участвуют сразу три операнда. В зависимости от условия тернарная операция возвращает второй или третий операнд: если условие равно true, то возвращается второй операнд; если условие равно false, то третий. Например:

Здесь результатом тернарной операции является переменная z. Сначала проверяется условие x<y. И если оно соблюдается, то z будет равно второму операнду - (x+y), иначе z будет равно третьему операнду.

Еще одним видом управляющих конструкций являются циклы. Циклы позволяют в зависимости от определенных условий выполнять определенное действие множество раз. В языке Java есть следующие виды циклов:

• for

• while

• do...while

Цикл for

Цикл for имеет следующее формальное определение:

Рассмотрим стандартный цикл for:

Первая часть объявления цикла - int i = 1 создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int. Это может быть и любой другой числовой тип, например, float. Перед выполнением цикла значение счетчика будет равно 1. В данном случае это то же самое, что и объявление переменной.

Вторая часть - условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 9.

И третья часть - приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i--.

В итоге блок цикла сработает 8 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.

Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:

Определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; ;). Теперь нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно - бесконечный цикл.

Либо можно опустить ряд блоков:

Этот пример эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть приращение счетчика уже в самом блоке for.

Цикл for может определять сразу несколько переменных и управлять ими:

Цикл do

Цикл do сначала выполняет код цикла, а потом проверяет условие в инструкции while. И пока это условие истинно, цикл повторяется. Например:

В данном случае код цикла сработает 7 раз, пока j не окажется равным нулю. Важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. Так, мы можем написать:

Хотя переменная j изначально меньше 0, цикл все равно один раз выполнится.

Цикл while

Цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:

Операторы continue и break

Оператор break позволяет выйти из цикла в любой его момент, даже если цикл не закончил свою работу:

Например:

Когда счетчик станет равным 5, сработает оператор break, и цикл завершится.

Теперь сделаем так, чтобы если число равно 5, цикл не завершался, а просто переходил к следующей итерации. Для этого используем оператор continue:

В этом случае, когда выполнение цикла дойдет до числа 5, программа просто пропустит это число и перейдет к следующему.

Массив представляет набор однотипных значений. Объявление массива похоже на объявление обычной переменной, которая хранит одиночное значение, причем есть два способа объявления массива:

Например, определим массив чисел:

После объявления массива мы можем инициализовать его:

Создание массива производится с помощью следующей конструкции: new тип_данных[количество_элементов], где new - ключевое слово, выделяющее память для указанного в скобках количества элементов. Например, nums = new int[4]; - в этом выражении создается массив из четырех элементов int, и каждый элемент будет иметь значение по умолчанию - число 0.

Также можно сразу при объявлении массива инициализировать его:

При подобной инициализации все элементы массива имеют значение по умолчанию. Для числовых типов (в том числе для типа char) это число 0, для типа boolean это значение false, а для остальных объектов это значение null. Например, для типа int значением по умолчанию является число 0, поэтому выше определенный массив nums будет состоять из четырех нулей.

Однако также можно задать конкретные значения для элементов массива при его создании:

Стоит отметить, что в этом случае в квадратных скобках не указывается размер массива, так как он вычисляется по количеству элементов в фигурных скобках.

После создания массива мы можем обратиться к любому его элементу по индексу, который передается в квадратных скобках после названия переменной массива:

Индексация элементов массива начинается с 0, поэтому в данном случае, чтобы обратиться к четвертому элементу в массиве, нам надо использовать выражение nums[3].

И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу: nums[5] = 5;. Если мы так попытаемся сделать, то мы получим ошибку.

Длина массива

Важнейшее свойство, которым обладают массивы, является свойство length, возвращающее длину массива, то есть количество его элементов:

Нередко бывает неизвестным последний индекс, и чтобы получить последний элемент массива, мы можем использовать это свойство:

Многомерные массивы

Ранее мы рассматривали одномерные массивы, которые можно представить как цепочку или строку однотипных значений. Но кроме одномерных массивов также бывают и многомерными. Наиболее известный многомерный массив - таблица, представляющая двухмерный массив:

Визуально оба массива можно представить следующим образом:

Одномерный массив nums1

Двухмерный массив nums2

Поскольку массив nums2 двухмерный, он представляет собой простую таблицу. Его также можно было создать следующим образом: int[][] nums2 = new int[2][3];. Количество квадратных скобок указывает на размерность массива. А числа в скобках - на количество строк и столбцов. И также, используя индексы, мы можем использовать элементы массива в программе:

Объявление трехмерного массива могло бы выглядеть так:

Зубчатый массив

Многомерные массивы могут быть также представлены как "зубчатые массивы". В вышеприведенном примере двухмерный массив имел 2 строчки и три столбца, поэтому у нас получалась ровная таблица. Но мы можем каждому элементу в двухмерном массиве присвоить отдельный массив с различным количеством элементов:

foreach

Специальная версия цикла for предназначена для перебора элементов в наборах элементов, например, в массивах и коллекциях. Она аналогична действию цикла foreach , который имеется в других языках программирования. Формальное ее объявление:

Например:

В качестве контейнера в данном случае выступает массив данных типа int. Затем объявляется переменная с типом int

То же самое можно было бы сделать и с помощью обычной версии for:

В то же время эта версия цикла for более гибкая по сравнению for (int i : array). В частности, в этой версии мы можем изменять элементы:

Перебор многомерных массивов в цикле

Сначала создается цикл для перебора по строкам, а затем внутри первого цикла создается внутренний цикл для перебора по столбцам конкретной строки. Подобным образом можно перебрать и трехмерные массивы и наборы с большим количеством размерностей.

Если переменные и константы хранят некоторые значения, то методы содержат собой набор операторов, которые выполняют определенные действия.

Общее определение методов выглядит следующим образом:

Модификаторы и параметры необязательны.

По умолчанию главный класс любой программы на Java содержит метод main, который служит точкой входа в программу:

Ключевые слова public и static являются модификаторами. Далее идет тип возвращаемого значения. Ключевое слово void указывает на то, что метод ничего не возвращает.

Затем идут название метода - main и в скобках параметры метода - String[] args. И в фигурные скобки заключено тело метода - все действия, которые он выполняет.

Создадим еще несколько методов:

Здесь определены два дополнительных метода: hello и welcome, каждый из которых выводит некоторую строку на консоль. Методы определяются внутри класса - в данном случае внутри класса Program, в котором определен метод main.

Но если мы скомпилируем и запустим данную программу, то мы ничего не увидим на консоли. В примере выше мы определили два метода, но мы их нигде не вызываем. По умолчанию в программе Java выполняется только метод main и все его содержимое. Поэтому, если мы хотим, чтобы другие методы тоже выполнялись, их надо вызвать в методе main.

Вызов метода осуществляется в форме:

После имени метода указываются скобки, в которых перечисляются аргументы - значения для параметров метода.

Например, определим и выполним несколько методов:

В методе main вызывается один раз метод hello и два раза метод welcome. В этом и заключается одно из преимуществ методов: мы можем вынести некоторые общие действия в отдельный метод и затем вызывать многократно их в различных местах программы. Поскольку оба метода не имеют никаких параметров, то после их названия при вызове ставятся пустые скобки.

Также следует отметить, что чтобы вызвать в методе main другие методы, которые определены в одном классе с методом main, они должны иметь модификатор static.

В итоге после компиляции и выполнения программы мы увидим на консоли:

Hello
Welcome to Java 10
Welcome to Java 10

С помощью параметров мы можем передать в методы различные данные, которые будут использоваться для вычислений. Например:

Данная функция принимает два параметра - два числа, складывает их и выводит их сумму на консоль.

А при вызове этого метода в программе нам необходимо передать на место параметров значения, которые соответствуют типу параметра:

Поскольку метод sum принимает два значения типа int, то на место параметров надо передать два значения типа int. Это могут быть и числовые литералы, и переменные типов данных, которые представляют тип int или могут быть автоматически преобразованы в тип int. Значения, которые передаются на место параметров, еще называются аргументами. Значения передаются параметрам по позиции, то есть первый аргумент первому параметру, второй аргумент - второму параметру и так далее.

Рассмотрим другой пример:

Метод display принимает два параметра. Первый параметр представляет тип String, а второй - тип int. Поэтому при вызове метода вначале в него надо передать строку, а затем число.

Параметры переменной длины

Метод может принимать параметры переменной длины одного типа. Например, нам надо передать в метод набор числел и вычислить их сумму, но мы точно не знаем, сколько именно чисел будет передано - 3, 4, 5 или больше. Параметры переменной длины позволяют решить эту задачу:

Троеточие перед названием параметра int ...nums указывает на то, что он будет необязательным и будет представлять массив. Мы можем передать в метод sum одно число, несколько чисел, а можем вообще не передавать никаких параметров. Причем, если мы хотим передать несколько параметров, то необязательный параметр должен указываться в конце:

Методы могут возвращать некоторое значение. Для этого применяется оператор return.

После оператора return указывается возвращаемое значение, которое является результатом метода. Это может быть литеральное значение, значение переменной или какого-то сложного выражения.

Например:

В методе в качестве типа возвращаемого значения вместо void используется любой другой тип. В данном случае метод sum возвращает значение типа int, поэтому этот тип указывается перед названием метода. Причем если в качестве возвращаемого типа для метода определен любой другой, отличный от void, то метод обязательно должен использовать оператор return для возвращения значения.

При этом возвращаемое значение всегда должно иметь тот же тип, что значится в определении функции. И если функция возвращает значение типа int, то после оператора return стоит целочисленное значение, которое является объектом типа int. Как в данном случае это сумма значений параметров метода.

Метод может использовать несколько вызовов оператора return для возваращения разных значений в зависимости от некоторых условий:

Здесь метод daytime возвращает значение типа String, то есть строку, и в зависимости от значения параметра hour возвращаемая строка будет различаться.

Выход из метода

Оператор return применяется для возвращаения значения из метода, но и для выхода из метода. В подобном качестве оператор return применяется в методах, которые ничего не возвращают, то есть имеют тип void:

Если переданное в метод datetime значение больше 24 или меньше 0, то просто выходим из метода. Возвращаемое значение после return указывать в этом случае не нужно.

В программе мы можем использовать методы с одним и тем же именем, но с разными типами и/или количеством параметров. Такой механизм называется перегрузкой методов (method overloading).

Например:

Здесь определено три варианта или три перегрузки метода sum(), но при его вызове в зависимости от типа и количества передаваемых параметров система выберет именно ту версию, которая наиболее подходит.

Стоит отметить, что на перегрузку методов влияют количество и типы параметров. Однако различие в типе возвращаемого значения для перегрузки не имеют никакого значения. Например, в следующем случае методы различаются по типу возвращаемого значения:

Однако перегрузкой это не будет считаться. Более того такая программа некорректна и попросту не скомилируется, так как метод с одним и тем же количеством и типом параметров определен несколько раз.

Отдельно рассмотрим рекурсивные функции. Главное отличие рекурсивных функций от обычных методов состоит в том, что они рекурсивная функция может вызывать саму себя.

Например, рассмотрим функцию, которая вычисляет факториал числа:

Вначале проверяется условие: если вводимое число не равно 1, то мы умножаем данное число на результат этой же функции, в которую в качестве параметра передается число x-1. То есть происходит рекурсивный спуск. И так дальше, пока не дойдем того момента, когда значение параметра не будет равно единице.

Рекурсивная функция обязательно должна иметь некоторый базовый вариант, который использует оператор return и который помещается в начале функции. В случае с факториалом это if (x == 1) return 1;. И все рекурсивные вызовы должны обращаться к подфункциям, которые в конечном счете сходятся к базовому варианту. Так, при передаче в функцию положительного числа при дальнейших рекурсивных вызовах подфункций в них будет передаваться каждый раз число, меньшее на единицу. И в конце концов мы дойдем до ситуации, когда число будет равно 1, и будет использован базовый вариант.

Хотя в данном случае нужно отметить, что для определения факториала есть более оптимальные решения на основе циклов:

Еще одним распространенным примером рекурсивной функции служит функция, вычисляющая числа Фибоначчи. В теории n-й член последовательности Фибоначчи определяется по формуле: f(n)=f(n-1) + f(n-2), причем f(0)=0, а f(1)=1.

Нередко в процессе выполнения программы могут возникать ошибки, при том необязательно по вине разработчика. Некоторые из них трудно предусмотреть или предвидеть, а иногда и вовсе невозможно. Так, например, может неожиданно оборваться сетевое подключение при передаче файла. Подобные ситуации называются исключениями.

В языке Java предусмотрены специальные средства для обработки подобных ситуаций. Одним из таких средств является конструкция try...catch...finally. При возникновении исключения в блоке try управление переходит в блок catch, который может обработать данное исключение. Если такого блока не найдено, то пользователю отображается сообщение о необработанном исключении, а дальнейшее выполнение программы останавливается. И чтобы подобной остановки не произошло, и надо использовать блок try..catch. Например:

Так как у нас массив numbers может содержать только 3 элемента, то при выполнении инструкции numbers[4]=45 консоль отобразит исключение, и выполнение программы будет завершено. Теперь попробуем обработать это исключение:

При использовании блока try...catch вначале выполняются все инструкции между операторами try и catch. Если в блоке try вдруг возникает исключение, то обычный порядок выполнения останавливается и переходит к инструкции сatch. Поэтому когда выполнение программы дойдет до строки numbers[4]=45;, программа остановится и перейдет к блоку catch

Выражение catch имеет следующий синтаксис: catch (тип_исключения имя_переменной). В данном случае объявляется переменная ex, которая имеет тип Exception. Но если возникшее исключение не является исключением типа, указанного в инструкции сatch, то оно не обрабатывается, а программа просто зависает или выбрасывает сообщение об ошибке.

Но так как тип Exception является базовым классом для всех исключений, то выражение catch (Exception ex) будет обрабатывать практически все исключения. Обработка же исключения в данном случае сводится к выводу на консоль стека трассировки ошибки с помощью метода printStackTrace(), определенного в классе Exception.

После завершения выполнения блока catch программа продолжает свою работу, выполняя все остальные инструкции после блока catch.

Конструкция try..catch также может иметь блок finally. Однако этот блок необязательный, и его можно при обработке исключений опускать. Блок finally выполняется в любом случае, возникло ли исключение в блоке try или нет:

Обработка нескольких исключений

В Java имеется множество различных типов исключений, и мы можем разграничить их обработку, включив дополнительные блоки catch:

Если у нас возникает исключение определенного типа, то оно переходит к соответствующему блоку catch.

Оператор throw

Чтобы сообщить о выполнении исключительных ситуаций в программе, можно использовать оператор throw. То есть с помощью этого оператора мы сами можем создать исключение и вызвать его в процессе выполнения. Например, в нашей программе происходит ввод числа, и мы хотим, чтобы, если число больше 30, то возникало исключение:

Здесь для создания объекта исключения используется конструктор класса Exception, в который передается сообщение об исключении. И если число х окажется больше 29, то будет выброшено исключение и управление перейдет к блоку catch.

В блоке catch мы можем получить сообщение об исключении с помощью метода getMessage().